home *** CD-ROM | disk | FTP | other *** search
/ Aminet 1 (Walnut Creek) / Aminet - June 1993 [Walnut Creek].iso / usenet / sources / volume2 / fun / nethack.d2 < prev    next >
Internet Message Format  |  1988-12-02  |  53KB
  1. Path: xanth!ames!nrl-cmf!ukma!rutgers!mit-eddie!ll-xn!adelie!infinet!ulowell!page
  2. From: page@swan.ulowell.edu (Bob Page)
  3. Newsgroups: comp.sources.amiga
  4. Subject: v02i071:  nethack - D&D-like game (amiga diffs), Part02/04
  5. Message-ID: <10402@swan.ulowell.edu>
  6. Date: 1 Dec 88 23:43:42 GMT
  7. Organization: University of Lowell, Computer Science Dept.
  8. Lines: 1820
  9. Approved: page@swan.ulowell.edu
  10.  
  11. Submitted-by: u211344@hnykun11.bitnet (Olaf 'Rhialto' Seibert)
  12. Posting-number: Volume 2, Issue 71
  13. Archive-name: fun/nethack.d2
  14.  
  15. #    This is a shell archive.
  16. #    Remove everything above and including the cut line.
  17. #    Then run the rest of the file through sh.
  18. #----cut here-----cut here-----cut here-----cut here----#
  19. #!/bin/sh
  20. # shar:    Shell Archiver
  21. #    Run the following text with /bin/sh to create:
  22. #    diffs.2
  23. # This archive created: Thu Dec  1 17:55:20 1988
  24. cat << \SHAR_EOF > diffs.2
  25.                 }
  26.                 if(!isok(u.ux+u.dx, u.uy+u.dy)){
  27. ***************
  28. *** 251,256
  29.         }
  30.         tmpr = &levl[u.ux+u.dx][u.uy+u.dy];
  31. !       if(IS_ROCK(tmpr->typ) ||
  32. !          (u.dx && u.dy && (tmpr->typ == DOOR || ust->typ == DOOR))){
  33.                 flags.move = 0;
  34.                 nomul(0);
  35.  
  36. --- 251,256 -----
  37.         }
  38.         tmpr = &levl[u.ux+u.dx][u.uy+u.dy];
  39. !       if(IS_ROCK(RM_TYP(*tmpr)) ||
  40. !          (u.dx && u.dy && (RM_TYP(*tmpr) == DOOR || RM_TYP(*ust) == DOOR))){
  41.                 flags.move = 0;
  42.                 nomul(0);
  43. ***************
  44. *** 258,263
  45.         }
  46.         if(moverock() < 0) return;
  47. !       if(u.dx && u.dy && IS_ROCK(levl[u.ux][u.uy+u.dy].typ) &&
  48. !               IS_ROCK(levl[u.ux+u.dx][u.uy].typ) &&
  49.                 invent && inv_weight()+40 > 0) {
  50.                 pline("You are carrying too much to get through.");
  51.  
  52. --- 258,263 -----
  53.         }
  54.         if(moverock() < 0) return;
  55. !       if(u.dx && u.dy && IS_ROCK(RM_TYP(levl[u.ux][u.uy+u.dy])) &&
  56. !               IS_ROCK(RM_TYP(levl[u.ux+u.dx][u.uy])) &&
  57.                 invent && inv_weight()+40 > 0) {
  58.                 pline("You are carrying too much to get through.");
  59. ***************
  60. *** 296,300
  61.         u.uy += u.dy;
  62.         if(flags.run) {
  63. !               if(tmpr->typ == DOOR ||
  64.                 (xupstair == u.ux && yupstair == u.uy) ||
  65.                 (xdnstair == u.ux && ydnstair == u.uy)
  66.  
  67. --- 296,300 -----
  68.         u.uy += u.dy;
  69.         if(flags.run) {
  70. !               if(RM_TYP(*tmpr) == DOOR ||
  71.                 (xupstair == u.ux && yupstair == u.uy) ||
  72.                 (xdnstair == u.ux && ydnstair == u.uy)
  73. ***************
  74. *** 300,304
  75.                 (xdnstair == u.ux && ydnstair == u.uy)
  76.   #ifdef FOUNTAINS
  77. !               || IS_FOUNTAIN(levl[u.ux][u.uy].typ)
  78.   #endif
  79.   #ifdef NEWCLASS
  80.  
  81. --- 300,304 -----
  82.                 (xdnstair == u.ux && ydnstair == u.uy)
  83.   #ifdef FOUNTAINS
  84. !               || IS_FOUNTAIN(RM_TYP(levl[u.ux][u.uy]))
  85.   #endif
  86.   #ifdef NEWCLASS
  87. ***************
  88. *** 303,307
  89.   #endif
  90.   #ifdef NEWCLASS
  91. !               || IS_THRONE(levl[u.ux][u.uy].typ)
  92.   #endif
  93.   #ifdef SINKS
  94.  
  95. --- 303,307 -----
  96.   #endif
  97.   #ifdef NEWCLASS
  98. !               || IS_THRONE(RM_TYP(levl[u.ux][u.uy]))
  99.   #endif
  100.   #ifdef SINKS
  101. ***************
  102. *** 306,310
  103.   #endif
  104.   #ifdef SINKS
  105. !               || IS_SINK(levl[u.ux][u.uy].typ)
  106.   #endif
  107.                 )
  108.  
  109. --- 306,310 -----
  110.   #endif
  111.   #ifdef SINKS
  112. !               || IS_SINK(RM_TYP(levl[u.ux][u.uy]))
  113.   #endif
  114.                 )
  115. ***************
  116. *** 313,317
  117.  
  118.   #ifdef SINKS
  119. !       if(IS_SINK(levl[u.ux][u.uy].typ) && Levitation)
  120.                 dosinkfall();
  121.   #endif
  122.  
  123. --- 313,317 -----
  124.  
  125.   #ifdef SINKS
  126. !       if(IS_SINK(RM_TYP(levl[u.ux][u.uy])) && Levitation)
  127.                 dosinkfall();
  128.   #endif
  129. ***************
  130. *** 316,320
  131.                 dosinkfall();
  132.   #endif
  133. !       if(tmpr->typ == POOL && !Levitation)
  134.                 drown();        /* not necessarily fatal */
  135.  
  136.  
  137. --- 316,320 -----
  138.                 dosinkfall();
  139.   #endif
  140. !       if(RM_TYP(*tmpr) == POOL && !Levitation)
  141.                 drown();        /* not necessarily fatal */
  142.  
  143. ***************
  144. *** 329,335
  145.                 setsee();
  146.   #else
  147. !               if(ust->lit) {
  148. !                       if(tmpr->lit) {
  149. !                               if(tmpr->typ == DOOR)
  150.                                         prl1(u.ux+u.dx,u.uy+u.dy);
  151.                                 else if(ust->typ == DOOR)
  152.  
  153. --- 329,335 -----
  154.                 setsee();
  155.   #else
  156. !               if(RM_LIT(*ust)) {
  157. !                       if(RM_LIT(*tmpr)) {
  158. !                               if(RM_TYP(*tmpr) == DOOR)
  159.                                         prl1(u.ux+u.dx,u.uy+u.dy);
  160.                                 else if(RM_TYP(*ust) == DOOR)
  161. ***************
  162. *** 333,337
  163.                                 if(tmpr->typ == DOOR)
  164.                                         prl1(u.ux+u.dx,u.uy+u.dy);
  165. !                               else if(ust->typ == DOOR)
  166.                                         nose1(u.ux0-u.dx,u.uy0-u.dy);
  167.                         } else {
  168.  
  169. --- 333,337 -----
  170.                                 if(RM_TYP(*tmpr) == DOOR)
  171.                                         prl1(u.ux+u.dx,u.uy+u.dy);
  172. !                               else if(RM_TYP(*ust) == DOOR)
  173.                                         nose1(u.ux0-u.dx,u.uy0-u.dy);
  174.                         } else {
  175. ***************
  176. *** 340,344
  177.                         }
  178.                 } else {
  179. !                       if(tmpr->lit) setsee();
  180.                         else {
  181.                                 prl1(u.ux+u.dx,u.uy+u.dy);
  182.  
  183. --- 340,344 -----
  184.                         }
  185.                 } else {
  186. !                       if(RM_LIT(*tmpr)) setsee();
  187.                         else {
  188.                                 prl1(u.ux+u.dx,u.uy+u.dy);
  189. ***************
  190. *** 343,347
  191.                         else {
  192.                                 prl1(u.ux+u.dx,u.uy+u.dy);
  193. !                               if(tmpr->typ == DOOR) {
  194.                                         if(u.dy) {
  195.                                                 prl(u.ux-1,u.uy);
  196.  
  197. --- 343,347 -----
  198.                         else {
  199.                                 prl1(u.ux+u.dx,u.uy+u.dy);
  200. !                               if(RM_TYP(*tmpr) == DOOR) {
  201.                                         if(u.dy) {
  202.                                                 prl(u.ux-1,u.uy);
  203. ***************
  204. *** 671,675
  205.   #endif
  206.         if(Blind || flags.run == 0) return;
  207. !       if(flags.run == 1 && levl[u.ux][u.uy].typ == ROOM) return;
  208.   #ifdef QUEST
  209.         if(u.ux0 == u.ux+u.dx && u.uy0 == u.uy+u.dy) goto stop;
  210.  
  211. --- 671,675 -----
  212.   #endif
  213.         if(Blind || flags.run == 0) return;
  214. !       if(flags.run == 1 && RM_TYP(levl[u.ux][u.uy]) == ROOM) return;
  215.   #ifdef QUEST
  216.         if(u.ux0 == u.ux+u.dx && u.uy0 == u.uy+u.dy) goto stop;
  217. ***************
  218. *** 677,681
  219.         for(x = u.ux-1; x <= u.ux+1; x++) for(y = u.uy-1; y <= u.uy+1; y++){
  220.                 if(x == u.ux && y == u.uy) continue;
  221. !               if(!levl[x][y].typ) continue;
  222.                 if((mtmp = m_at(x,y)) && !mtmp->mimic &&
  223.                     (!mtmp->minvis || See_invisible)){
  224.  
  225. --- 677,681 -----
  226.         for(x = u.ux-1; x <= u.ux+1; x++) for(y = u.uy-1; y <= u.uy+1; y++){
  227.                 if(x == u.ux && y == u.uy) continue;
  228. !               if(!RM_TYP(levl[x][y])) continue;
  229.                 if((mtmp = m_at(x,y)) && !mtmp->mimic &&
  230.                     (!mtmp->minvis || See_invisible)){
  231. ***************
  232. *** 782,786
  233.         if(d < 3) return(1);
  234.         if(d > u.uhorizon*u.uhorizon) return(0);
  235. !       if(!levl[x][y].lit)
  236.                 return(0);
  237.         dx = x - u.ux;  adx = abs(dx);  sdx = sgn(dx);
  238.  
  239. --- 782,786 -----
  240.         if(d < 3) return(1);
  241.         if(d > u.uhorizon*u.uhorizon) return(0);
  242. !       if(!RM_LIT(levl[x][y]))
  243.                 return(0);
  244.         dx = x - u.ux;  adx = abs(dx);  sdx = sgn(dx);
  245. ***************
  246. *** 810,814
  247.  
  248.   rroom(x,y) register int x,y; {
  249. !       return(IS_ROOM(levl[u.ux+x][u.uy+y].typ));
  250.   }
  251.  
  252.  
  253. --- 810,814 -----
  254.  
  255.   rroom(x,y) register int x,y; {
  256. !       return(IS_ROOM(RM_TYP(levl[u.ux+x][u.uy+y])));
  257.   }
  258.  
  259. ***************
  260. *** 818,822
  261.         if(Blind || u.uswallow) return(0);
  262.         if(dist(x,y) < 3) return(1);
  263. !       if(levl[x][y].lit && seelx <= x && x <= seehx && seely <= y &&
  264.                 y <= seehy) return(1);
  265.         return(0);
  266.  
  267. --- 818,822 -----
  268.         if(Blind || u.uswallow) return(0);
  269.         if(dist(x,y) < 3) return(1);
  270. !       if(RM_LIT(levl[x][y]) && seelx <= x && x <= seehx && seely <= y &&
  271.                 y <= seehy) return(1);
  272.         return(0);
  273. ***************
  274. *** 854,858
  275.                 return;
  276.         }
  277. !       if(!levl[u.ux][u.uy].lit) {
  278.                 seelx = u.ux-1;
  279.                 seehx = u.ux+1;
  280.  
  281. --- 854,858 -----
  282.                 return;
  283.         }
  284. !       if(!RM_LIT(levl[u.ux][u.uy])) {
  285.                 seelx = u.ux-1;
  286.                 seehx = u.ux+1;
  287. ***************
  288. *** 860,867
  289.                 seehy = u.uy+1;
  290.         } else {
  291. !               for(seelx = u.ux; levl[seelx-1][u.uy].lit; seelx--);
  292. !               for(seehx = u.ux; levl[seehx+1][u.uy].lit; seehx++);
  293. !               for(seely = u.uy; levl[u.ux][seely-1].lit; seely--);
  294. !               for(seehy = u.uy; levl[u.ux][seehy+1].lit; seehy++);
  295.         }
  296.         for(y = seely; y <= seehy; y++)
  297.  
  298. --- 860,867 -----
  299.                 seehy = u.uy+1;
  300.         } else {
  301. !               for(seelx = u.ux; RM_LIT(levl[seelx-1][u.uy]); seelx--);
  302. !               for(seehx = u.ux; RM_LIT(levl[seehx+1][u.uy]); seehx++);
  303. !               for(seely = u.uy; RM_LIT(levl[u.ux][seely-1]); seely--);
  304. !               for(seehy = u.uy; RM_LIT(levl[u.ux][seehy+1]); seehy++);
  305.         }
  306.         for(y = seely; y <= seehy; y++)
  307. ***************
  308. *** 869,873
  309.                         prl(x,y);
  310.         }
  311. !       if(!levl[u.ux][u.uy].lit) seehx = 0; /* seems necessary elsewhere */
  312.         else {
  313.             if(seely == u.uy) for(x = u.ux-1; x <= u.ux+1; x++) prl(x,seely-1);
  314.  
  315. --- 869,873 -----
  316.                         prl(x,y);
  317.         }
  318. !       if(!RM_LIT(levl[u.ux][u.uy])) seehx = 0; /* seems necessary elsewhere */
  319.         else {
  320.             if(seely == u.uy) for(x = u.ux-1; x <= u.ux+1; x++) prl(x,seely-1);
  321. diff -bc2 invent.c df1:invent.c
  322. *** invent.c    Wed May  4 15:08:10 1988
  323. --- df1:invent.c        Fri Jul 22 21:36:54 1988
  324. ***************
  325. *** 802,806
  326.       /* added by GAN 10/30/86 */
  327.   #ifdef FOUNTAINS
  328. !     if(IS_FOUNTAIN(levl[u.ux][u.uy].typ))  {
  329.         fd++;
  330.         pline("There is a fountain here.");
  331.  
  332. --- 802,806 -----
  333.       /* added by GAN 10/30/86 */
  334.   #ifdef FOUNTAINS
  335. !     if(IS_FOUNTAIN(RM_TYP(levl[u.ux][u.uy])))  {
  336.         fd++;
  337.         pline("There is a fountain here.");
  338. ***************
  339. *** 808,812
  340.   #endif
  341.   #ifdef NEWCLASS
  342. !     if(IS_THRONE(levl[u.ux][u.uy].typ))  {
  343.         fd++;
  344.         pline("There is an opulent throne here.");
  345.  
  346. --- 808,812 -----
  347.   #endif
  348.   #ifdef NEWCLASS
  349. !     if(IS_THRONE(RM_TYP(levl[u.ux][u.uy])))  {
  350.         fd++;
  351.         pline("There is an opulent throne here.");
  352. ***************
  353. *** 814,818
  354.   #endif
  355.   #ifdef SINKS
  356. !     if(IS_SINK(levl[u.ux][u.uy].typ))  {
  357.         fd++;
  358.         pline("There is a kitchen sink here.");
  359.  
  360. --- 814,818 -----
  361.   #endif
  362.   #ifdef SINKS
  363. !     if(IS_SINK(RM_TYP(levl[u.ux][u.uy])))  {
  364.         fd++;
  365.         pline("There is a kitchen sink here.");
  366. diff -bc2 lev.c df1:lev.c
  367. *** lev.c       Wed May  4 15:08:12 1988
  368. --- df1:lev.c   Thu Aug  4 12:43:17 1988
  369. ***************
  370. *** 34,37
  371.   {
  372.         if (mode & COUNT) {
  373.                 count_only = TRUE;
  374.                 bytes_counted = 0;
  375.  
  376. --- 34,42 -----
  377.   {
  378.         if (mode & COUNT) {
  379. + #ifdef COMPRESS /* Should be superfluous */
  380. +               if (!count_only)    /* Did we just write? */
  381. +                   bflush(0);
  382. +               /*dbg();*/
  383. + #endif
  384.                 count_only = TRUE;
  385.                 bytes_counted = 0;
  386. ***************
  387. *** 42,45
  388.         }
  389.         if (mode & WRITE) {
  390.                 count_only = FALSE;
  391.                 bytes_counted = 0;
  392.  
  393. --- 47,54 -----
  394.         }
  395.         if (mode & WRITE) {
  396. + #ifdef COMPRESS
  397. +               if (mode & COUNT)    /* Did we just count? */
  398. +                   bflush(fd);
  399. + #endif
  400.                 count_only = FALSE;
  401.                 bytes_counted = 0;
  402. ***************
  403. *** 114,117
  404.   }
  405.  
  406.   bwrite(fd,loc,num)
  407.   register fd;
  408.  
  409. --- 123,246 -----
  410.   }
  411.  
  412. + #ifdef COMPRESS
  413. +
  414. + #define RLESC '\0'    /* Leading character for run of LRESC's */
  415. + #define flushoutrun(ln) bputc(RLESC); bputc(ln); ln = -1;
  416. +
  417. + static unsigned char outbuf[BUFSZ];
  418. + static unsigned short outbufp = 0;
  419. + static short outrunlength = -1;
  420. + static int bwritefd;
  421. +
  422. + /*dbg()
  423. + {
  424. +    printf("outbufp %d outrunlength %d\n", outbufp,outrunlength);
  425. + }*/
  426. +
  427. + static bputc(c)
  428. + unsigned char c;
  429. + {
  430. + #ifdef        DGK
  431. +     bytes_counted++;
  432. +     if (count_only)
  433. +       return;
  434. + #endif
  435. +     if (outbufp >= BUFSZ) {
  436. +       write(bwritefd, outbuf, (int) BUFSZ);
  437. +       outbufp = 0;
  438. +     }
  439. +     outbuf[outbufp++] = c;
  440. + }
  441. +
  442. + bflush(fd)  /* flush run and buffer */
  443. + register fd;
  444. + {
  445. +       bwritefd = fd;
  446. +       if (outrunlength >= 0) {    /* flush run */
  447. +           flushoutrun(outrunlength);
  448. +       }
  449. +       if (outbufp) {
  450. + #ifdef        DGK
  451. +           if (!count_only)    /* flush buffer */
  452. + #endif
  453. +                   write(fd, outbuf, outbufp);
  454. +           outbufp = 0;
  455. +       }
  456. +       /*printf("bflush()"); getret();*/
  457. + }
  458. +
  459. + bwrite(fd, loc, num)
  460. + register fd;
  461. + register char *loc;
  462. + register unsigned num;
  463. + {
  464. +       bwritefd = fd;
  465. +       for (; num; num--, loc++) {
  466. +               if (*loc == RLESC) { /* One more char in run */
  467. +                   if (++outrunlength == 0xFF) {
  468. +                       flushoutrun(outrunlength);
  469. +                   }
  470. +               } else { /* end of run */
  471. +                   if (outrunlength >= 0) {    /* flush run */
  472. +                       flushoutrun(outrunlength);
  473. +                   }
  474. +                   bputc(*loc);
  475. +               }
  476. +       }
  477. + }
  478. +
  479. + static unsigned char inbuf[BUFSZ];
  480. + static unsigned short inbufp = 0;
  481. + static unsigned short inbufsz = 0;
  482. + static short inrunlength = -1;
  483. + static int mreadfd;
  484. +
  485. + static int mgetc()
  486. + {
  487. +     if (inbufp >= inbufsz) {
  488. +       inbufsz = read(mreadfd, (char *)inbuf, (int)sizeof inbuf);
  489. +       if (!inbufsz) {
  490. +           if (inbufp > sizeof inbuf)
  491. +               error("EOF on file #%d.\n", mreadfd);
  492. +           inbufp = 1 + sizeof inbuf;  /* exactly one warning :-) */
  493. +           return -1;
  494. +       }
  495. +       inbufp = 0;
  496. +     }
  497. +     return inbuf[inbufp++];
  498. + }
  499. +
  500. + minit()
  501. + {
  502. +     inbufsz = 0;
  503. +     inbufp = 0;
  504. +     inrunlength = -1;
  505. + }
  506. +
  507. + mread(fd, buf, len)
  508. + int fd;
  509. + register char *buf;
  510. + register unsigned len;
  511. + {
  512. +     /*register int readlen = 0;*/
  513. +     mreadfd = fd;
  514. +     while (len--) {
  515. +       if (inrunlength > 0) {
  516. +           inrunlength--;
  517. +           *buf++ = '\0';
  518. +       } else {
  519. +           register short ch = mgetc();
  520. +           if (ch < 0) return -1; /*readlen;*/
  521. +           if ((*buf++ = ch) == RLESC) {
  522. +               inrunlength = mgetc();
  523. +           }
  524. +       }
  525. +       /*readlen++;*/
  526. +     }
  527. +     return 0; /*readlen;*/
  528. + }
  529. +
  530. + #else /* COMPRESS */
  531. +
  532.   bwrite(fd,loc,num)
  533.   register fd;
  534. ***************
  535. *** 128,131
  536.   }
  537.  
  538.   saveobjchn(fd,otmp)
  539.   register fd;
  540.  
  541. --- 257,280 -----
  542.   }
  543.  
  544. + mread(fd, buf, len)
  545. + register fd;
  546. + register char *buf;
  547. + register unsigned len;
  548. + {
  549. +       register int rlen;
  550. +       extern boolean restoring;
  551. +
  552. +       rlen = read(fd, buf, (int) len);
  553. +       if(rlen != len){
  554. +               pline("Read %d instead of %u bytes.\n", rlen, len);
  555. +               if(restoring) {
  556. +                       (void) unlink(SAVEF);
  557. +                       error("Error restoring old game.");
  558. +               }
  559. +               panic("Error reading level file.");
  560. +       }
  561. + }
  562. + #endif
  563. +
  564.   saveobjchn(fd,otmp)
  565.   register fd;
  566. ***************
  567. *** 167,170
  568.                 bwrite(fd, (char *) mtmp, xl + sizeof(struct monst));
  569.                 if(mtmp->minvent) saveobjchn(fd,mtmp->minvent);
  570.                 free((char *) mtmp);
  571.                 mtmp = mtmp2;
  572.  
  573. --- 316,322 -----
  574.                 bwrite(fd, (char *) mtmp, xl + sizeof(struct monst));
  575.                 if(mtmp->minvent) saveobjchn(fd,mtmp->minvent);
  576. + #ifdef DGK
  577. +               if (!count_only)
  578. + #endif
  579.                         free((char *) mtmp);
  580.                 mtmp = mtmp2;
  581. ***************
  582. *** 234,237
  583.         if((pid && pid != hpid) || (lev && dlvl != lev)) {
  584.                 pline("Strange, this map is not as I remember it.");
  585.                 pline("Somebody is trying some trickery here ...");
  586.                 pline("This game is void ...");
  587.  
  588. --- 386,390 -----
  589.         if((pid && pid != hpid) || (lev && dlvl != lev)) {
  590.                 pline("Strange, this map is not as I remember it.");
  591. +            /* pline("pid = %x (%x), lev = %d (%d).", hpid, pid, dlvl, lev); */
  592.                 pline("Somebody is trying some trickery here ...");
  593.                 pline("This game is void ...");
  594. ***************
  595. *** 254,258
  596.                                 osym = levl[x][y].scrsym;
  597.                                 nsym = 0;
  598. !                               switch (levl[x][y].typ) {
  599.                                 case 0:
  600.                                 case SCORR:
  601.  
  602. --- 407,411 -----
  603.                                 osym = levl[x][y].scrsym;
  604.                                 nsym = 0;
  605. !                               switch (RM_TYP(levl[x][y])) {
  606.                                 case 0:
  607.                                 case SCORR:
  608. ***************
  609. *** 282,289
  610.                                 /* Now the ugly stuff */
  611.                                 case HWALL:
  612. !                                 up = (y > 0) ? levl[x][y-1].typ : 0;
  613. !                                 dn = (y < ROWNO-1) ?levl[x][y+1].typ : 0;
  614. !                                 lt = (x > 0) ? levl[x-1][y].typ : 0;
  615. !                                 rt = (x < COLNO-1) ?levl[x+1][y].typ : 0;
  616.                                   up = up && (up == VWALL || up == DOOR
  617.                                         || up == SDOOR);
  618.  
  619. --- 435,442 -----
  620.                                 /* Now the ugly stuff */
  621.                                 case HWALL:
  622. !                                 up = (y > 0) ? RM_TYP(levl[x][y-1]) : 0;
  623. !                                 dn = (y < ROWNO-1) ? RM_TYP(levl[x][y+1]) : 0;
  624. !                                 lt = (x > 0) ? RM_TYP(levl[x-1][y]) : 0;
  625. !                                 rt = (x < COLNO-1) ? RM_TYP(levl[x+1][y]) : 0;
  626.                                   up = up && (up == VWALL || up == DOOR
  627.                                         || up == SDOOR);
  628. ***************
  629. *** 397,407
  630.   }
  631.  
  632. - mread(fd, buf, len)
  633. - register fd;
  634. - register char *buf;
  635. - register unsigned len;
  636. - {
  637. -       register int rlen;
  638. -       extern boolean restoring;
  639.  
  640.         rlen = read(fd, buf, (int) len);
  641.  
  642. --- 550,553 -----
  643.   }
  644.  
  645.  
  646.   mklev()
  647. ***************
  648. *** 405,419
  649.         extern boolean restoring;
  650.  
  651. -       rlen = read(fd, buf, (int) len);
  652. -       if(rlen != len){
  653. -               pline("Read %d instead of %u bytes.\n", rlen, len);
  654. -               if(restoring) {
  655. -                       (void) unlink(SAVEF);
  656. -                       error("Error restoring old game.");
  657. -               }
  658. -               panic("Error reading level file.");
  659. -       }
  660. - }
  661. -
  662.   mklev()
  663.   {
  664.  
  665. --- 551,554 -----
  666.  
  667.  
  668.   mklev()
  669.   {
  670. ***************
  671. *** 488,492
  672.         int nfrom, nto, fdfrom, fdto;
  673.  
  674. !       if ((fdfrom = open(from, O_RDONLY | O_BINARY | O_CREAT, FMASK)) < 0)
  675.                 panic("Can't copy from %s !?", from);
  676.         if ((fdto = open(to, O_WRONLY | O_BINARY | O_CREAT, FMASK)) < 0)
  677.  
  678. --- 623,627 -----
  679.         int nfrom, nto, fdfrom, fdto;
  680.  
  681. !       if ((fdfrom = open(from, O_RDONLY | O_BINARY, FMASK)) < 0)
  682.                 panic("Can't copy from %s !?", from);
  683.         if ((fdto = open(to, O_WRONLY|O_BINARY|O_CREAT|O_TRUNC, FMASK)) < 0)
  684. ***************
  685. *** 490,494
  686.         if ((fdfrom = open(from, O_RDONLY | O_BINARY | O_CREAT, FMASK)) < 0)
  687.                 panic("Can't copy from %s !?", from);
  688. !       if ((fdto = open(to, O_WRONLY | O_BINARY | O_CREAT, FMASK)) < 0)
  689.                 panic("Can't copy to %s", to);
  690.         do {
  691.  
  692. --- 625,629 -----
  693.         if ((fdfrom = open(from, O_RDONLY | O_BINARY, FMASK)) < 0)
  694.                 panic("Can't copy from %s !?", from);
  695. !       if ((fdto = open(to, O_WRONLY|O_BINARY|O_CREAT|O_TRUNC, FMASK)) < 0)
  696.                 panic("Can't copy to %s", to);
  697.         do {
  698. diff -bc2 makemon.c df1:makemon.c
  699. *** makemon.c   Wed May  4 15:08:16 1988
  700. --- df1:makemon.c       Mon Jul 25 01:42:37 1988
  701. ***************
  702. *** 101,105
  703.         }
  704.   gotmon:
  705. ! #if defined(KJSMODS) && defined(ROCKMOLE)
  706.         /* make a giant rat */
  707.         if((zlevel < 4 && ptr->mlet == 'r')
  708.  
  709. --- 101,107 -----
  710.         }
  711.   gotmon:
  712. ! /* #if defined(KJSMODS) && defined(ROCKMOLE) */
  713. ! #ifdef KJSMODS
  714. ! # ifdef ROCKMOLE
  715.         /* make a giant rat */
  716.         if((zlevel < 4 && ptr->mlet == 'r')
  717. ***************
  718. *** 107,110
  719.            || (zlevel == 2 && (ptr->mlet == 'o' || ptr->mlet == 'y'))
  720.         ) ptr = &giant_rat;
  721.   #endif
  722.         mtmp = newmonst(ptr->pxlth);
  723.  
  724. --- 109,113 -----
  725.            || (zlevel == 2 && (ptr->mlet == 'o' || ptr->mlet == 'y'))
  726.         ) ptr = &giant_rat;
  727. + # endif
  728.   #endif
  729.         mtmp = newmonst(ptr->pxlth);
  730. ***************
  731. *** 181,185
  732.                                 &mons[zlevel+14+rn2(CMNUM-14-zlevel)]);
  733.   # else
  734. !                               0);
  735.   # endif
  736.   #endif
  737.  
  738. --- 184,188 -----
  739.                                 &mons[zlevel+14+rn2(CMNUM-14-zlevel)]);
  740.   # else
  741. !                               Null(permonst));
  742.   # endif
  743.   #endif
  744. ***************
  745. *** 363,367
  746.         return(
  747.         ! (x < 1 || x > COLNO-2 || y < 1 || y > ROWNO-2 ||
  748. !          m_at(x,y) || !ACCESSIBLE(levl[x][y].typ)
  749.            || (x == u.ux && y == u.uy)
  750.            || sobj_at(ENORMOUS_ROCK, x, y)
  751.  
  752. --- 366,370 -----
  753.         return(
  754.         ! (x < 1 || x > COLNO-2 || y < 1 || y > ROWNO-2 ||
  755. !          m_at(x,y) || !ACCESSIBLE(RM_TYP(levl[x][y]))
  756.            || (x == u.ux && y == u.uy)
  757.            || sobj_at(ENORMOUS_ROCK, x, y)
  758. diff -bc2 mhitu.c df1:mhitu.c
  759. *** mhitu.c     Wed May  4 15:08:20 1988
  760. --- df1:mhitu.c         Mon Jul 25 01:45:27 1988
  761. ***************
  762. *** 128,132
  763.                                 u.ustuck = mtmp;
  764.                         } else if(u.ustuck == mtmp &&
  765. !                           levl[mtmp->mx][mtmp->my].typ == POOL) {
  766.                                 pline("%s drowns you ...", Monnam(mtmp));
  767.                                 done("drowned");
  768.  
  769. --- 128,132 -----
  770.                                 u.ustuck = mtmp;
  771.                         } else if(u.ustuck == mtmp &&
  772. !                           RM_TYP(levl[mtmp->mx][mtmp->my]) == POOL) {
  773.                                 pline("%s drowns you ...", Monnam(mtmp));
  774.                                 done("drowned");
  775. diff -bc2 mklev.c df1:mklev.c
  776. *** mklev.c     Wed May  4 15:08:22 1988
  777. --- df1:mklev.c         Mon Jul 25 02:14:04 1988
  778. ***************
  779. *** 91,95
  780.         ydnstair = somey();
  781.         levl[xdnstair][ydnstair].scrsym = DN_SYM;
  782. !       levl[xdnstair][ydnstair].typ = STAIRS;
  783.   #ifdef RPH
  784.         { struct monst *mtmp;
  785.  
  786. --- 91,95 -----
  787.         ydnstair = somey();
  788.         levl[xdnstair][ydnstair].scrsym = DN_SYM;
  789. !       RM_SET_TYP(levl[xdnstair][ydnstair], STAIRS);
  790.   #ifdef RPH
  791.         { struct monst *mtmp;
  792. ***************
  793. *** 128,132
  794.         yupstair = somey();
  795.         levl[xupstair][yupstair].scrsym = UP_SYM;
  796. !       levl[xupstair][yupstair].typ = STAIRS;
  797.  
  798.         /* for each room: put things inside */
  799.  
  800. --- 128,132 -----
  801.         yupstair = somey();
  802.         levl[xupstair][yupstair].scrsym = UP_SYM;
  803. !       RM_SET_TYP(levl[xupstair][yupstair], STAIRS);
  804.  
  805.         /* for each room: put things inside */
  806. ***************
  807. *** 378,382
  808.  
  809.         for(x = xl; x <= xh; x++) for(y = yl; y <= yh; y++)
  810. !               if(levl[x][y].typ == DOOR || levl[x][y].typ == SDOOR)
  811.                         goto gotit;
  812.         /* cannot find something reasonable -- strange */
  813.  
  814. --- 378,382 -----
  815.  
  816.         for(x = xl; x <= xh; x++) for(y = yl; y <= yh; y++)
  817. !               if(RM_TYP(levl[x][y]) == DOOR || RM_TYP(levl[x][y]) == SDOOR)
  818.                         goto gotit;
  819.         /* cannot find something reasonable -- strange */
  820. ***************
  821. *** 393,401
  822.   register x,y;
  823.   {
  824. !       if(levl[x-1][y].typ == DOOR || levl[x+1][y].typ == DOOR ||
  825. !          levl[x][y+1].typ == DOOR || levl[x][y-1].typ == DOOR ||
  826. !          levl[x-1][y].typ == SDOOR || levl[x+1][y].typ == SDOOR ||
  827. !          levl[x][y-1].typ == SDOOR || levl[x][y+1].typ == SDOOR ||
  828. !          (levl[x][y].typ != HWALL && levl[x][y].typ != VWALL) ||
  829.            doorindex >= DOORMAX)
  830.                 return(0);
  831.  
  832. --- 393,401 -----
  833.   register x,y;
  834.   {
  835. !       if(RM_TYP(levl[x-1][y]) == DOOR || RM_TYP(levl[x+1][y]) == DOOR ||
  836. !          RM_TYP(levl[x][y+1]) == DOOR || RM_TYP(levl[x][y-1]) == DOOR ||
  837. !          RM_TYP(levl[x-1][y]) == SDOOR || RM_TYP(levl[x+1][y]) == SDOOR ||
  838. !          RM_TYP(levl[x][y-1]) == SDOOR || RM_TYP(levl[x][y+1]) == SDOOR ||
  839. !          (RM_TYP(levl[x][y]) != HWALL && RM_TYP(levl[x][y]) != VWALL) ||
  840.            doorindex >= DOORMAX)
  841.                 return(0);
  842. ***************
  843. *** 424,428
  844.         register tmp;
  845.  
  846. !       if(!IS_WALL(levl[x][y].typ))    /* avoid SDOORs with DOOR_SYM as scrsym
  847. */
  848.                 type = DOOR;
  849.         levl[x][y].typ = type;
  850.  
  851. --- 424,428 -----
  852.         register tmp;
  853.  
  854. !       if(!IS_WALL(RM_TYP(levl[x][y]))) /* avoid SDOORs with DOOR_SYM as scrsym
  855. */
  856.                 type = DOOR;
  857.         RM_SET_TYP(levl[x][y], type);
  858. ***************
  859. *** 426,430
  860.         if(!IS_WALL(levl[x][y].typ))    /* avoid SDOORs with DOOR_SYM as scrsym
  861. */
  862.                 type = DOOR;
  863. !       levl[x][y].typ = type;
  864.         if(type == DOOR)
  865.                 levl[x][y].scrsym = DOOR_SYM;
  866.  
  867. --- 426,430 -----
  868.         if(!IS_WALL(RM_TYP(levl[x][y]))) /* avoid SDOORs with DOOR_SYM as scrsym
  869. */
  870.                 type = DOOR;
  871. !       RM_SET_TYP(levl[x][y], type);
  872.         if(type == DOOR)
  873.                 levl[x][y].scrsym = DOOR_SYM;
  874. ***************
  875. *** 459,463
  876.         for(x = lowx - xlim; x <= hix + xlim; x++) {
  877.                 for(y = lowy - ylim; y <= hiy + ylim; y++) {
  878. !                       if(levl[x][y].typ) {
  879.   #ifdef WIZARD
  880.                             if(wizard && !secret)
  881.  
  882. --- 459,463 -----
  883.         for(x = lowx - xlim; x <= hix + xlim; x++) {
  884.                 for(y = lowy - ylim; y <= hiy + ylim; y++) {
  885. !                       if(RM_TYP(levl[x][y])) {
  886.   #ifdef WIZARD
  887.                             if(wizard && !secret)
  888. ***************
  889. *** 485,489
  890.                 for(x = lowx-1; x <= hix+1; x++)
  891.                         for(y = lowy-1; y <= hiy+1; y++)
  892. !                               levl[x][y].lit = 1;
  893.                 croom->rlit = 1;
  894.         } else
  895.  
  896. --- 485,489 -----
  897.                 for(x = lowx-1; x <= hix+1; x++)
  898.                         for(y = lowy-1; y <= hiy+1; y++)
  899. !                               RM_SET_LIT(levl[x][y]);
  900.                 croom->rlit = 1;
  901.         } else
  902. ***************
  903. *** 499,503
  904.             for(y = lowy-1; y <= hiy+1; y += (hiy-lowy+2)) {
  905.                 levl[x][y].scrsym = HWALL_SYM;
  906. !               levl[x][y].typ = HWALL;
  907.         }
  908.         for(x = lowx-1; x <= hix+1; x += (hix-lowx+2))
  909.  
  910. --- 499,503 -----
  911.             for(y = lowy-1; y <= hiy+1; y += (hiy-lowy+2)) {
  912.                 levl[x][y].scrsym = HWALL_SYM;
  913. !               RM_SET_TYP(levl[x][y], HWALL);
  914.         }
  915.         for(x = lowx-1; x <= hix+1; x += (hix-lowx+2))
  916. ***************
  917. *** 504,508
  918.             for(y = lowy; y <= hiy; y++) {
  919.                 levl[x][y].scrsym = VWALL_SYM;
  920. !               levl[x][y].typ = VWALL;
  921.         }
  922.         for(x = lowx; x <= hix; x++)
  923.  
  924. --- 504,508 -----
  925.             for(y = lowy; y <= hiy; y++) {
  926.                 levl[x][y].scrsym = VWALL_SYM;
  927. !               RM_SET_TYP(levl[x][y], VWALL);
  928.         }
  929.         for(x = lowx; x <= hix; x++)
  930. ***************
  931. *** 509,513
  932.             for(y = lowy; y <= hiy; y++) {
  933.                 levl[x][y].scrsym = ROOM_SYM;
  934. !               levl[x][y].typ = ROOM;
  935.         }
  936.         levl[lowx-1][lowy-1].scrsym = TLCORN_SYM;
  937.  
  938. --- 509,513 -----
  939.             for(y = lowy; y <= hiy; y++) {
  940.                 levl[x][y].scrsym = ROOM_SYM;
  941. !               RM_SET_TYP(levl[x][y], ROOM);
  942.         }
  943.         levl[lowx-1][lowy-1].scrsym = TLCORN_SYM;
  944. ***************
  945. *** 594,598
  946.         tx = tt.x - dx;
  947.         ty = tt.y - dy;
  948. !       if(nxcor && levl[xx+dx][yy+dy].typ)
  949.                 return;
  950.         dodoor(xx,yy,croom);
  951.  
  952. --- 594,598 -----
  953.         tx = tt.x - dx;
  954.         ty = tt.y - dy;
  955. !       if(nxcor && RM_TYP(levl[xx+dx][yy+dy]))
  956.                 return;
  957.         dodoor(xx,yy,croom);
  958. ***************
  959. *** 611,615
  960.  
  961.             crm = &levl[xx][yy];
  962. !           if(!(crm->typ)) {
  963.                 if(rn2(100)) {
  964.                         crm->typ = CORR;
  965.  
  966. --- 611,615 -----
  967.  
  968.             crm = &levl[xx][yy];
  969. !           if(!(RM_TYP(*crm))) {
  970.                 if(rn2(100)) {
  971.                         RM_SET_TYP(*crm, CORR);
  972. ***************
  973. *** 613,617
  974.             if(!(crm->typ)) {
  975.                 if(rn2(100)) {
  976. !                       crm->typ = CORR;
  977.                         crm->scrsym = CORR_SYM;
  978.                         if(nxcor && !rn2(50))
  979.  
  980. --- 613,617 -----
  981.             if(!(RM_TYP(*crm))) {
  982.                 if(rn2(100)) {
  983. !                       RM_SET_TYP(*crm, CORR);
  984.                         crm->scrsym = CORR_SYM;
  985.                         if(nxcor && !rn2(50))
  986. ***************
  987. *** 618,622
  988.                                 (void) mkobj_at(ROCK_SYM, xx, yy);
  989.                 } else {
  990. !                       crm->typ = SCORR;
  991.                         crm->scrsym = STONE_SYM;
  992.                 }
  993.  
  994. --- 618,622 -----
  995.                                 (void) mkobj_at(ROCK_SYM, xx, yy);
  996.                 } else {
  997. !                       RM_SET_TYP(*crm, SCORR);
  998.                         crm->scrsym = STONE_SYM;
  999.                 }
  1000. ***************
  1001. *** 622,626
  1002.                 }
  1003.             } else
  1004. !           if(crm->typ != CORR && crm->typ != SCORR) {
  1005.                 /* strange ... */
  1006.                 return;
  1007.  
  1008. --- 622,626 -----
  1009.                 }
  1010.             } else
  1011. !           if(RM_TYP(*crm) != CORR && RM_TYP(*crm) != SCORR) {
  1012.                 /* strange ... */
  1013.                 return;
  1014. ***************
  1015. *** 636,640
  1016.  
  1017.                 crm = &levl[xx+ddx][yy];
  1018. !               if(!crm->typ || crm->typ == CORR || crm->typ == SCORR) {
  1019.                     dx = ddx;
  1020.                     dy = 0;
  1021.  
  1022. --- 636,640 -----
  1023.  
  1024.                 crm = &levl[xx+ddx][yy];
  1025. !               if(!RM_TYP(*crm) || RM_TYP(*crm) == CORR || RM_TYP(*crm) ==
  1026. SCORR) {
  1027.                     dx = ddx;
  1028.                     dy = 0;
  1029. ***************
  1030. *** 645,649
  1031.  
  1032.                 crm = &levl[xx][yy+ddy];
  1033. !               if(!crm->typ || crm->typ == CORR || crm->typ == SCORR) {
  1034.                     dy = ddy;
  1035.                     dx = 0;
  1036.  
  1037. --- 645,649 -----
  1038.  
  1039.                 crm = &levl[xx][yy+ddy];
  1040. !               if(!RM_TYP(*crm) || RM_TYP(*crm) == CORR || RM_TYP(*crm) ==
  1041. SCORR) {
  1042.                     dy = ddy;
  1043.                     dx = 0;
  1044. ***************
  1045. *** 654,658
  1046.             /* continue straight on? */
  1047.             crm = &levl[xx+dx][yy+dy];
  1048. !           if(!crm->typ || crm->typ == CORR || crm->typ == SCORR)
  1049.                 continue;
  1050.  
  1051.  
  1052. --- 654,658 -----
  1053.             /* continue straight on? */
  1054.             crm = &levl[xx+dx][yy+dy];
  1055. !           if(!RM_TYP(*crm) || RM_TYP(*crm) == CORR || RM_TYP(*crm) == SCORR)
  1056.                 continue;
  1057.  
  1058. ***************
  1059. *** 662,666
  1060.                 dy = (ty < yy) ? -1 : 1;
  1061.                 crm = &levl[xx+dx][yy+dy];
  1062. !               if(!crm->typ || crm->typ == CORR || crm->typ == SCORR)
  1063.                     continue;
  1064.                 dy = -dy;
  1065.  
  1066. --- 662,666 -----
  1067.                 dy = (ty < yy) ? -1 : 1;
  1068.                 crm = &levl[xx+dx][yy+dy];
  1069. !               if(!RM_TYP(*crm) || RM_TYP(*crm) == CORR || RM_TYP(*crm) ==
  1070. SCORR)
  1071.                     continue;
  1072.                 dy = -dy;
  1073. ***************
  1074. *** 670,674
  1075.                 dx = (tx < xx) ? -1 : 1;
  1076.                 crm = &levl[xx+dx][yy+dy];
  1077. !               if(!crm->typ || crm->typ == CORR || crm->typ == SCORR)
  1078.                     continue;
  1079.                 dx = -dx;
  1080.  
  1081. --- 670,674 -----
  1082.                 dx = (tx < xx) ? -1 : 1;
  1083.                 crm = &levl[xx+dx][yy+dy];
  1084. !               if(!RM_TYP(*crm) || RM_TYP(*crm) == CORR || RM_TYP(*crm) ==
  1085. SCORR)
  1086.                     continue;
  1087.                 dx = -dx;
  1088. ***************
  1089. *** 767,771
  1090.             xx = dd.x;
  1091.             yy = dd.y;
  1092. !           if((rm = &levl[xx][yy+dy])->typ) continue;
  1093.             if(trap_type || !rn2(4)) {
  1094.  
  1095.  
  1096. --- 767,771 -----
  1097.             xx = dd.x;
  1098.             yy = dd.y;
  1099. !           if((rm = &levl[xx][yy+dy]), RM_TYP(*rm)) continue;
  1100.             if(trap_type || !rn2(4)) {
  1101.  
  1102. ***************
  1103. *** 770,774
  1104.             if(trap_type || !rn2(4)) {
  1105.  
  1106. !               rm->typ = SCORR;
  1107.                 rm->scrsym = STONE_SYM;
  1108.                 if(trap_type) {
  1109.  
  1110. --- 770,774 -----
  1111.             if(trap_type || !rn2(4)) {
  1112.  
  1113. !               RM_SET_TYP(*rm, SCORR);
  1114.                 rm->scrsym = STONE_SYM;
  1115.                 if(trap_type) {
  1116. ***************
  1117. *** 780,784
  1118.                 dosdoor(xx, yy, aroom, SDOOR);
  1119.             } else {
  1120. !               rm->typ = CORR;
  1121.                 rm->scrsym = CORR_SYM;
  1122.                 if(rn2(7))
  1123.  
  1124. --- 780,784 -----
  1125.                 dosdoor(xx, yy, aroom, SDOOR);
  1126.             } else {
  1127. !               RM_SET_TYP(*rm, CORR);
  1128.                 rm->scrsym = CORR_SYM;
  1129.                 if(rn2(7))
  1130. ***************
  1131. *** 887,891
  1132.                                 my = somey();
  1133.                         }
  1134. !               } while(m_at(mx,my) || levl[mx][my].typ == STAIRS);
  1135.                 if(mtmp = makemon(PM_MIMIC,mx,my)) {
  1136.                     mtmp->mimic = 1;
  1137.  
  1138. --- 887,891 -----
  1139.                                 my = somey();
  1140.                         }
  1141. !               } while(m_at(mx,my) || RM_TYP(levl[mx][my]) == STAIRS);
  1142.                 if(mtmp = makemon(PM_MIMIC,mx,my)) {
  1143.                     mtmp->mimic = 1;
  1144. ***************
  1145. *** 914,918
  1146.                         my = somey();
  1147.                 }
  1148. !       } while(t_at(mx, my) || levl[mx][my].typ == STAIRS);
  1149.         ttmp = maketrap(mx, my, kind);
  1150.   #ifdef SPIDERS
  1151.  
  1152. --- 914,918 -----
  1153.                         my = somey();
  1154.                 }
  1155. !       } while(t_at(mx, my) || RM_TYP(levl[mx][my]) == STAIRS);
  1156.         ttmp = maketrap(mx, my, kind);
  1157.   #ifdef SPIDERS
  1158. ***************
  1159. *** 943,947
  1160.                       my = somey();
  1161.               }
  1162. !       } while(t_at(mx, my) || levl[mx][my].typ == STAIRS
  1163.   #ifdef NEWCLASS
  1164.               || IS_THRONE(levl[mx][my].typ)
  1165.  
  1166. --- 943,947 -----
  1167.                       my = somey();
  1168.               }
  1169. !       } while(t_at(mx, my) || RM_TYP(levl[mx][my]) == STAIRS
  1170.   #ifdef NEWCLASS
  1171.               || IS_THRONE(RM_TYP(levl[mx][my]))
  1172. ***************
  1173. *** 945,949
  1174.         } while(t_at(mx, my) || levl[mx][my].typ == STAIRS
  1175.   #ifdef NEWCLASS
  1176. !             || IS_THRONE(levl[mx][my].typ)
  1177.   #endif
  1178.              );
  1179.  
  1180. --- 945,949 -----
  1181.         } while(t_at(mx, my) || RM_TYP(levl[mx][my]) == STAIRS
  1182.   #ifdef NEWCLASS
  1183. !             || IS_THRONE(RM_TYP(levl[mx][my]))
  1184.   #endif
  1185.              );
  1186. ***************
  1187. *** 951,955
  1188.          /* Put a fountain at mx, my */
  1189.  
  1190. !        levl[mx][my].typ = FOUNTAIN;
  1191.          levl[mx][my].scrsym = FOUNTAIN_SYM;
  1192.  
  1193.  
  1194. --- 951,955 -----
  1195.          /* Put a fountain at mx, my */
  1196.  
  1197. !        RM_SET_TYP(levl[mx][my], FOUNTAIN);
  1198.          levl[mx][my].scrsym = FOUNTAIN_SYM;
  1199.  
  1200. ***************
  1201. *** 969,973
  1202.               mx = somex();
  1203.               my = somey();
  1204. !       } while(t_at(mx, my) || levl[mx][my].typ == STAIRS
  1205.   #ifdef FOUNTAINS
  1206.               || IS_FOUNTAIN(levl[mx][my].typ)
  1207.  
  1208. --- 969,973 -----
  1209.               mx = somex();
  1210.               my = somey();
  1211. !       } while(t_at(mx, my) || RM_TYP(levl[mx][my]) == STAIRS
  1212.   #ifdef FOUNTAINS
  1213.               || IS_FOUNTAIN(RM_TYP(levl[mx][my]))
  1214. ***************
  1215. *** 971,975
  1216.         } while(t_at(mx, my) || levl[mx][my].typ == STAIRS
  1217.   #ifdef FOUNTAINS
  1218. !             || IS_FOUNTAIN(levl[mx][my].typ)
  1219.   #endif
  1220.   #ifdef NEWCLASS
  1221.  
  1222. --- 971,975 -----
  1223.         } while(t_at(mx, my) || RM_TYP(levl[mx][my]) == STAIRS
  1224.   #ifdef FOUNTAINS
  1225. !             || IS_FOUNTAIN(RM_TYP(levl[mx][my]))
  1226.   #endif
  1227.   #ifdef NEWCLASS
  1228. ***************
  1229. *** 974,978
  1230.   #endif
  1231.   #ifdef NEWCLASS
  1232. !             || IS_THRONE(levl[mx][my].typ)
  1233.   #endif
  1234.              );
  1235.  
  1236. --- 974,978 -----
  1237.   #endif
  1238.   #ifdef NEWCLASS
  1239. !             || IS_THRONE(RM_TYP(levl[mx][my]))
  1240.   #endif
  1241.              );
  1242. ***************
  1243. *** 980,984
  1244.          /* Put a sink at mx, my */
  1245.  
  1246. !        levl[mx][my].typ = SINK;
  1247.          levl[mx][my].scrsym = SINK_SYM;
  1248.  
  1249.  
  1250. --- 980,984 -----
  1251.          /* Put a sink at mx, my */
  1252.  
  1253. !        RM_SET_TYP(levl[mx][my], SINK);
  1254.          levl[mx][my].scrsym = SINK_SYM;
  1255.  
  1256. diff -bc2 mon.c df1:mon.c
  1257. *** mon.c       Wed May  4 15:08:28 1988
  1258. --- df1:mon.c   Sat Jul 23 00:32:30 1988
  1259. ***************
  1260. *** 45,49
  1261.                   extern struct permonst pm_gremlin;
  1262.  
  1263. !                 inpool = (levl[mtmp->mx][mtmp->my].typ == POOL);
  1264.                   iseel = (mtmp->data->mlet == ';');
  1265.                   isgremlin = (mtmp->data->mlet == 'G' && mtmp->isgremlin);
  1266.  
  1267. --- 45,49 -----
  1268.                   extern struct permonst pm_gremlin;
  1269.  
  1270. !                 inpool = (RM_TYP(levl[mtmp->mx][mtmp->my]) == POOL);
  1271.                   iseel = (mtmp->data->mlet == ';');
  1272.                   isgremlin = (mtmp->data->mlet == 'G' && mtmp->isgremlin);
  1273. ***************
  1274. *** 48,52
  1275.                   iseel = (mtmp->data->mlet == ';');
  1276.                   isgremlin = (mtmp->data->mlet == 'G' && mtmp->isgremlin);
  1277. !                 infountain = (levl[mtmp->mx][mtmp->my].typ == FOUNTAIN);
  1278.                   if((inpool || infountain) && isgremlin && rn2(3)) {
  1279.                         coord mm;
  1280.  
  1281. --- 48,52 -----
  1282.                   iseel = (mtmp->data->mlet == ';');
  1283.                   isgremlin = (mtmp->data->mlet == 'G' && mtmp->isgremlin);
  1284. !                 infountain = (RM_TYP(levl[mtmp->mx][mtmp->my]) == FOUNTAIN);
  1285.                   if((inpool || infountain) && isgremlin && rn2(3)) {
  1286.                         coord mm;
  1287. ***************
  1288. *** 231,235
  1289.         x = mon->mx;
  1290.         y = mon->my;
  1291. !       nowtyp = levl[x][y].typ;
  1292.  
  1293.         pool = (mon->data->mlet == ';');
  1294.  
  1295. --- 231,235 -----
  1296.         x = mon->mx;
  1297.         y = mon->my;
  1298. !       nowtyp = RM_TYP(levl[x][y]);
  1299.  
  1300.         pool = (mon->data->mlet == ';');
  1301. ***************
  1302. *** 243,247
  1303.         if(nx != x || ny != y) if(isok(nx,ny))
  1304.   #ifdef ROCKMOLE
  1305. !       if(!IS_ROCK(ntyp = levl[nx][ny].typ) || (flag & ALLOW_WALL))
  1306.   #else
  1307.         if(!IS_ROCK(ntyp = levl[nx][ny].typ))
  1308.  
  1309. --- 243,247 -----
  1310.         if(nx != x || ny != y) if(isok(nx,ny))
  1311.   #ifdef ROCKMOLE
  1312. !       if(!IS_ROCK(ntyp = RM_TYP(levl[nx][ny])) || (flag & ALLOW_WALL))
  1313.   #else
  1314.         if(!IS_ROCK(ntyp = RM_TYP(levl[nx][ny])))
  1315. ***************
  1316. *** 245,249
  1317.         if(!IS_ROCK(ntyp = levl[nx][ny].typ) || (flag & ALLOW_WALL))
  1318.   #else
  1319. !       if(!IS_ROCK(ntyp = levl[nx][ny].typ))
  1320.   #endif
  1321.         if(!(nx != x && ny != y && (nowtyp == DOOR || ntyp == DOOR)))
  1322.  
  1323. --- 245,249 -----
  1324.         if(!IS_ROCK(ntyp = RM_TYP(levl[nx][ny])) || (flag & ALLOW_WALL))
  1325.   #else
  1326. !       if(!IS_ROCK(ntyp = RM_TYP(levl[nx][ny])))
  1327.   #endif
  1328.         if(!(nx != x && ny != y && (nowtyp == DOOR || ntyp == DOOR)))
  1329. ***************
  1330. *** 627,631
  1331.   # endif
  1332.   #endif
  1333. !       if(!ACCESSIBLE(levl[x][y].typ)) {
  1334.             /* might be mimic in wall or dead eel*/
  1335.             newsym(x,y);
  1336.  
  1337. --- 627,631 -----
  1338.   # endif
  1339.   #endif
  1340. !       if(!ACCESSIBLE(RM_TYP(levl[x][y]))) {
  1341.             /* might be mimic in wall or dead eel*/
  1342.             newsym(x,y);
  1343. ***************
  1344. *** 817,821
  1345.            && !rn2(3)) {
  1346.                 mtmp->mimic = 1;
  1347. !               mtmp->mappearance = (levl[mtmp->mx][mtmp->my].typ == DOOR) ?
  1348. DOOR_SYM : GOLD_SYM;
  1349.                 return(1);
  1350.            }
  1351.  
  1352. --- 817,821 -----
  1353.            && !rn2(3)) {
  1354.                 mtmp->mimic = 1;
  1355. !               mtmp->mappearance = (RM_TYP(levl[mtmp->mx][mtmp->my]) == DOOR) ?
  1356. DOOR_SYM : GOLD_SYM;
  1357.                 return(1);
  1358.            }
  1359. ***************
  1360. *** 825,829
  1361.            && !rn2(3))  {
  1362.  
  1363. !               if(levl[mtmp->mx][mtmp->my].typ == ROOM)  {
  1364.  
  1365.                         maketrap(mtmp->mx, mtmp->my, PIERC);
  1366.  
  1367. --- 825,829 -----
  1368.            && !rn2(3))  {
  1369.  
  1370. !               if(RM_TYP(levl[mtmp->mx][mtmp->my]) == ROOM)  {
  1371.  
  1372.                         maketrap(mtmp->mx, mtmp->my, PIERC);
  1373. diff -bc2 monmove.c df1:monmove.c
  1374. *** monmove.c   Wed May  4 15:08:32 1988
  1375. --- df1:monmove.c       Sun Jul 24 14:01:44 1988
  1376. ***************
  1377. *** 192,196
  1378.         if((msym == 't' && !rn2(5))
  1379.         || (msym == '1' && (mtmp->mhp < 7 || (!xdnstair && !rn2(5))
  1380. !               || levl[u.ux][u.uy].typ == STAIRS))) {
  1381.                 if(mtmp->mhp < 7 || (msym == 't' && rn2(2)))
  1382.                         rloc(mtmp);
  1383.  
  1384. --- 192,196 -----
  1385.         if((msym == 't' && !rn2(5))
  1386.         || (msym == '1' && (mtmp->mhp < 7 || (!xdnstair && !rn2(5))
  1387. !               || RM_TYP(levl[u.ux][u.uy]) == STAIRS))) {
  1388.                 if(mtmp->mhp < 7 || (msym == 't' && rn2(2)))
  1389.                         rloc(mtmp);
  1390. ***************
  1391. *** 425,430
  1392.                   && dlevel > 3
  1393.   #endif
  1394. !                 && IS_ROCK(levl[mtmp->mx][mtmp->my].typ) &&
  1395. !                 levl[mtmp->mx][mtmp->my].typ != POOL){
  1396.                    register int pile = rnd(25);
  1397.                    /* Just ate something. */
  1398.  
  1399. --- 425,430 -----
  1400.                   && dlevel > 3
  1401.   #endif
  1402. !                 && IS_ROCK(RM_TYP(levl[mtmp->mx][mtmp->my])) &&
  1403. !                 RM_TYP(levl[mtmp->mx][mtmp->my]) != POOL){
  1404.                    register int pile = rnd(25);
  1405.                    /* Just ate something. */
  1406. ***************
  1407. *** 429,436
  1408.                    register int pile = rnd(25);
  1409.                    /* Just ate something. */
  1410. !                  if(levl[mtmp->mx][mtmp->my].typ == 0)
  1411. !                    levl[mtmp->mx][mtmp->my].typ = CORR;
  1412. !                  else if(IS_WALL(levl[mtmp->mx][mtmp->my].typ))
  1413. !                    levl[mtmp->mx][mtmp->my].typ = DOOR;
  1414.                    mnewsym(mtmp->mx,mtmp->my);
  1415.                    /* Left behind a pile? */
  1416.  
  1417. --- 429,436 -----
  1418.                    register int pile = rnd(25);
  1419.                    /* Just ate something. */
  1420. !                  if (RM_TYP(levl[mtmp->mx][mtmp->my]) == 0)
  1421. !                    RM_SET_TYP(levl[mtmp->mx][mtmp->my], CORR);
  1422. !                  else if (IS_WALL(RM_TYP(levl[mtmp->mx][mtmp->my])))
  1423. !                    RM_SET_TYP(levl[mtmp->mx][mtmp->my], DOOR);
  1424.                    mnewsym(mtmp->mx,mtmp->my);
  1425.                    /* Left behind a pile? */
  1426. diff -bc2 msdos.c df1:msdos.c
  1427. *** msdos.c     Wed May  4 15:08:36 1988
  1428. --- df1:msdos.c         Sun Jul 24 23:52:30 1988
  1429. ***************
  1430. *** 520,524
  1431.   #ifdef GRAPHICS
  1432.                 } else if (!strncmp(buf, "GRAPHICS", 4)) {
  1433. !                       char translate[17];
  1434.                         short i;
  1435.  
  1436.  
  1437. --- 520,524 -----
  1438.   #ifdef GRAPHICS
  1439.                 } else if (!strncmp(buf, "GRAPHICS", 4)) {
  1440. !                       unsigned int translate[MAXPCHARS];
  1441.                         short i;
  1442.  
  1443. ***************
  1444. *** 523,527
  1445.                         short i;
  1446.  
  1447. !                    if ((i = sscanf(bufp, "%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u",
  1448.                                 &translate[0], &translate[1], &translate[2],
  1449.                                 &translate[3], &translate[4], &translate[5],
  1450.  
  1451. --- 523,527 -----
  1452.                         short i;
  1453.  
  1454. !                    if ((i = sscanf(bufp,
  1455. "%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d",
  1456.                         &translate[0], &translate[1], &translate[2],
  1457.                         &translate[3], &translate[4], &translate[5],
  1458. ***************
  1459. *** 529,533
  1460.                                 &translate[9], &translate[10], &translate[11],
  1461.                                 &translate[12], &translate[13], &translate[14],
  1462. !                               &translate[15], &translate[16])) < 0) {
  1463.                                         msmsg ("Syntax error in GRAPHICS\n");
  1464.                                         getreturn("to continue");
  1465.  
  1466. --- 529,533 -----
  1467.                         &translate[9], &translate[10], &translate[11],
  1468.                         &translate[12], &translate[13], &translate[14],
  1469. !                       &translate[15], &translate[16], &translate[17])) < 0) {
  1470.                             msmsg ("Syntax error in GRAPHICS\n");
  1471.                             getreturn("to continue");
  1472. ***************
  1473. *** 533,537
  1474.                                         getreturn("to continue");
  1475.                         }
  1476. -                       translate[i] = '\0';
  1477.   #endif /* GRAPHICS /**/
  1478.   /*
  1479.  
  1480. --- 533,536 -----
  1481.                             getreturn("to continue");
  1482.                         }
  1483.   #endif /* GRAPHICS /**/
  1484.   /*
  1485. ***************
  1486. *** 539,543
  1487.    * in or out and forget to change the tail entries in your graphics string.
  1488.    */
  1489. ! #define SETPCHAR(f, n)        showsyms.f = (strlen(translate) > n) ?
  1490. translate[n] : defsyms.f
  1491.                         SETPCHAR(stone, 0);
  1492.                         SETPCHAR(vwall, 1);
  1493.  
  1494. --- 538,542 -----
  1495.    * in or out and forget to change the tail entries in your graphics string.
  1496.    */
  1497. ! #define SETPCHAR(f, n)  showsyms.f = (i > n) ? translate[n] : defsyms.f
  1498.                         SETPCHAR(stone, 0);
  1499.                         SETPCHAR(vwall, 1);
  1500. ***************
  1501. *** 562,565
  1502.   #ifdef SPIDERS
  1503.                         SETPCHAR(web, 16);
  1504.   #endif
  1505.   #undef SETPCHAR
  1506.  
  1507. --- 561,567 -----
  1508.   #ifdef SPIDERS
  1509.                         SETPCHAR(web, 16);
  1510. + #endif
  1511. + #ifdef SINKS
  1512. +                       SETPCHAR(sink, 17);
  1513.   #endif
  1514.   #undef SETPCHAR
  1515.  
  1516.  
  1517. diff -bc2 o_init.c Amiga:o_init.c
  1518. *** o_init.c    Tue May  3 16:58:02 1988
  1519. --- Amiga:o_init.c        Thu Jul 28 23:15:29 1988
  1520. ***************
  1521. *** 60,63
  1522.                             while(--j > first)
  1523.                                 /* NOTE:  longest color name must be default */
  1524.                                 if(!strcmp(objects[j].oc_name,"turquoise")) {
  1525.                                     if(rn2(2)) /* change from green? */
  1526.  
  1527. --- 60,64 -----
  1528.                             while(--j > first)
  1529.                                 /* NOTE:  longest color name must be default */
  1530. +                               /* NOTE: these names won't get saved (OIS)*/
  1531.                                 if(!strcmp(objects[j].oc_name,"turquoise")) {
  1532.                                     if(rn2(2)) /* change from green? */
  1533. ***************
  1534. *** 130,135
  1535.   register int i;
  1536.   unsigned len;
  1537. ! struct objclass *now = &objects[0];
  1538. !       bwrite(fd, (char *) &now, sizeof now);
  1539.         bwrite(fd, (char *) bases, sizeof bases);
  1540.         bwrite(fd, (char *) objects, sizeof objects);
  1541.  
  1542. --- 131,138 -----
  1543.   register int i;
  1544.   unsigned len;
  1545. ! /* char *now = objects[0].oc_name; */
  1546. ! /* The place where the string literals are put seems */
  1547. ! /* like a better reference point to me (OIS) */
  1548. !       /* bwrite(fd, (char *) &now, sizeof now); */
  1549.         bwrite(fd, (char *) bases, sizeof bases);
  1550.         bwrite(fd, (char *) objects, sizeof objects);
  1551. ***************
  1552. *** 137,140
  1553.            need not save oc_name and oc_descr, but we must save
  1554.            oc_uname for all objects */
  1555.         for(i=0; i < SIZE(objects); i++) {
  1556.                 if(objects[i].oc_uname) {
  1557.  
  1558. --- 140,145 -----
  1559.            need not save oc_name and oc_descr, but we must save
  1560.            oc_uname for all objects */
  1561. +       /* we also save food, weapons, tools, balls, chains, rocks,
  1562. +          armor, which is a real waste... (OIS) */
  1563.         for(i=0; i < SIZE(objects); i++) {
  1564.                 if(objects[i].oc_uname) {
  1565. ***************
  1566. *** 149,153
  1567.   register int i;
  1568.   unsigned len;
  1569. ! struct objclass *then;
  1570.   long differ;
  1571.         mread(fd, (char *) &then, sizeof then);
  1572.  
  1573. --- 154,158 -----
  1574.   register int i;
  1575.   unsigned len;
  1576. ! /* char *then; */
  1577.   long differ;
  1578.         /* mread(fd, (char *) &then, sizeof then); */
  1579. ***************
  1580. *** 151,155
  1581.   struct objclass *then;
  1582.   long differ;
  1583. !       mread(fd, (char *) &then, sizeof then);
  1584.         mread(fd, (char *) bases, sizeof bases);
  1585.         mread(fd, (char *) objects, sizeof objects);
  1586.  
  1587. --- 156,161 -----
  1588.   /* char *then; */
  1589.   long differ;
  1590. !       /* mread(fd, (char *) &then, sizeof then); */
  1591. !       differ = (long) objects[0].oc_name;
  1592.         mread(fd, (char *) bases, sizeof bases);
  1593.         mread(fd, (char *) objects, sizeof objects);
  1594. ***************
  1595. *** 155,159
  1596.         mread(fd, (char *) objects, sizeof objects);
  1597.   #ifndef MSDOS
  1598. !       differ = (char *)&objects[0] - (char *)then;
  1599.   #else
  1600.         differ = (long)&objects[0] - (long)then;
  1601.  
  1602. --- 161,166 -----
  1603.         mread(fd, (char *) objects, sizeof objects);
  1604.   #ifndef MSDOS
  1605. !       /* differ = (char *)&objects[0] - (char *)then; */
  1606. !       differ = differ /* == our refpoint */ - objects[0].oc_name /* old */;
  1607.   #else
  1608.         differ = differ - (long)objects[0].oc_name;
  1609. ***************
  1610. *** 157,161
  1611.         differ = (char *)&objects[0] - (char *)then;
  1612.   #else
  1613. !       differ = (long)&objects[0] - (long)then;
  1614.   #endif
  1615.         for(i=0; i < SIZE(objects); i++) {
  1616.  
  1617. --- 164,168 -----
  1618.         differ = differ /* == our refpoint */ - objects[0].oc_name /* old */;
  1619.   #else
  1620. !       differ = differ - (long)objects[0].oc_name;
  1621.   #endif
  1622.         for(i=0; i < SIZE(objects); i++) {
  1623. diff -bc2 obj.h Amiga:obj.h
  1624. No differences encountered
  1625. diff -bc2 objclass.h Amiga:objclass.h
  1626. No differences encountered
  1627. diff -bc2 objects.h Amiga:objects.h
  1628. No differences encountered
  1629. diff -bc2 pcmain.c Amiga:pcmain.c
  1630. *** pcmain.c    Wed May  4 15:08:46 1988
  1631. --- Amiga:pcmain.c        Wed Jul 27 23:33:56 1988
  1632. ***************
  1633. *** 1,5
  1634.   /*    SCCS Id: @(#)pcmain.c   2.3     87/12/12
  1635.   /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  1636. ! /* main.c - (PC) version */
  1637.  
  1638.   #include <stdio.h>
  1639.  
  1640. --- 1,5 -----
  1641.   /*    SCCS Id: @(#)pcmain.c   2.3     87/12/12
  1642.   /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  1643. ! /* main.c - (PC and AMIGA) version */
  1644.  
  1645.   #include <stdio.h>
  1646. ***************
  1647. *** 7,12
  1648.   #include "hack.h"
  1649.  
  1650. ! #ifdef QUEST
  1651. ! #define       gamename        "PC NetQuest"
  1652.   #else
  1653.   #define       gamename        "PC NetHack"
  1654.  
  1655. --- 7,16 -----
  1656.   #include "hack.h"
  1657.  
  1658. ! #ifdef AMIGA
  1659. ! # ifdef QUEST
  1660. ! #  define    gamename  "Amiga NetQuest"
  1661. ! # else
  1662. ! #  define    gamename  "Amiga NetHack"
  1663. ! # endif
  1664.   #else
  1665.   # ifdef QUEST
  1666. ***************
  1667. *** 10,14
  1668.   #define       gamename        "PC NetQuest"
  1669.   #else
  1670. ! #define       gamename        "PC NetHack"
  1671.   #endif
  1672.  
  1673.  
  1674. --- 14,22 -----
  1675.   # endif
  1676.   #else
  1677. ! # ifdef QUEST
  1678. ! #  define    gamename  "PC NetQuest"
  1679. ! # else
  1680. ! #  define    gamename  "PC NetHack"
  1681. ! # endif
  1682.   #endif
  1683.  
  1684. ***************
  1685. *** 13,16
  1686.   #endif
  1687.  
  1688.   char orgdir[PATHLEN], *getcwd();
  1689.  
  1690.  
  1691. --- 21,27 -----
  1692.   #endif
  1693.  
  1694. + #ifdef AMIGA
  1695. + extern char orgdir[1];
  1696. + #else
  1697.   char orgdir[PATHLEN], *getcwd();
  1698.   #endif
  1699. ***************
  1700. *** 14,17
  1701.  
  1702.   char orgdir[PATHLEN], *getcwd();
  1703.  
  1704.   extern struct permonst mons[CMNUM+2];
  1705.  
  1706. --- 25,29 -----
  1707.   #else
  1708.   char orgdir[PATHLEN], *getcwd();
  1709. + #endif
  1710.  
  1711.   extern struct permonst mons[CMNUM+2];
  1712. ***************
  1713. *** 37,40
  1714.         register char *dir;
  1715.         extern struct monst *makedog();
  1716.   #ifdef MSDOS
  1717.         static void moveloop(); /* a helper function for MSC optimizer */
  1718.  
  1719. --- 49,66 -----
  1720.         register char *dir;
  1721.         extern struct monst *makedog();
  1722. +
  1723. + #ifdef AMIGA
  1724. +       char ch;
  1725. +       int abort;
  1726. +
  1727. + /*
  1728. +  *  Make sure screen IO is initialized before anything happens.
  1729. +  */
  1730. +
  1731. +       gettty();
  1732. +       startup();
  1733. +       hackpid = getpid();
  1734. + #endif
  1735. +
  1736.   #ifdef MSDOS
  1737.   # ifndef AMIGA
  1738. ***************
  1739. *** 38,41
  1740.         extern struct monst *makedog();
  1741.   #ifdef MSDOS
  1742.         static void moveloop(); /* a helper function for MSC optimizer */
  1743.  
  1744.  
  1745. --- 64,68 -----
  1746.  
  1747.   #ifdef MSDOS
  1748. + # ifndef AMIGA
  1749.         static void moveloop(); /* a helper function for MSC optimizer */
  1750.  
  1751. ***************
  1752. *** 53,56
  1753.                          */
  1754.         signal(SIGINT, funcp);  /* restore original directory */
  1755.   #endif
  1756.  
  1757.  
  1758. --- 80,84 -----
  1759.                          */
  1760.         signal(SIGINT, funcp);  /* restore original directory */
  1761. + # endif
  1762.   #endif
  1763.  
  1764. ***************
  1765. *** 69,73
  1766.                 (void) strcpy(hackdir, orgdir);
  1767.         dir = hackdir;
  1768. ! #else
  1769.         dir = getenv("HACKDIR");
  1770.         if(argc > 1 && !strncmp(argv[1], "-d", 2)) {
  1771.  
  1772. --- 97,101 -----
  1773.                 (void) strcpy(hackdir, orgdir);
  1774.         dir = hackdir;
  1775. ! #else /* DGK */
  1776.         dir = getenv("HACKDIR");
  1777.         if(argc > 1 && !strncmp(argv[1], "-d", 2)) {
  1778. ***************
  1779. *** 100,103
  1780.          * Remember tty modes, to be restored on exit.
  1781.          */
  1782.         gettty();
  1783.         setbuf(stdout,obuf);
  1784.  
  1785. --- 128,132 -----
  1786.          * Remember tty modes, to be restored on exit.
  1787.          */
  1788. + #ifndef AMIGA
  1789.         gettty();
  1790.         setbuf(stdout,obuf);
  1791. ***************
  1792. *** 102,106
  1793.         gettty();
  1794.         setbuf(stdout,obuf);
  1795. -       setrandom();
  1796.         startup();
  1797.         init_corpses(); /* initialize optional corpse names */
  1798.  
  1799. --- 131,134 -----
  1800.         gettty();
  1801.         setbuf(stdout,obuf);
  1802.         startup();
  1803.   #endif /* !AMIGA */
  1804. ***************
  1805. *** 104,107
  1806.         setrandom();
  1807.         startup();
  1808.         init_corpses(); /* initialize optional corpse names */
  1809.         cls();
  1810.  
  1811. --- 132,137 -----
  1812.         setbuf(stdout,obuf);
  1813.         startup();
  1814. + #endif /* !AMIGA */
  1815. +       setrandom();
  1816.         init_corpses(); /* initialize optional corpse names */
  1817.         cls();
  1818. ***************
  1819. *** 125,129
  1820.   # ifdef MSDOS
  1821.                         wizard = TRUE;
  1822. ! # else
  1823.                         if(!strcmp(getlogin(), WIZARD))
  1824.                                 wizard = TRUE;
  1825. SHAR_EOF
  1826. #    End of shell archive
  1827. exit 0
  1828. -- 
  1829. Bob Page, U of Lowell CS Dept.  page@swan.ulowell.edu  ulowell!page
  1830. Have five nice days.
  1831.